#include <string>

#include "Exceptions.h"
#include <string.h>

using namespace std;

static const string EMPTY = "";

//-----------------------------------------------------------------------------
char* copyString(const char* str) {

	if (str == 0) return 0;
		 	
	int length = strlen(str);
	char* result = new char[length + 1];
	strcpy(result, str);
	result[length] = '\0';

	return result;
}

///////////////////////////////////////////////////////////////////////////////
// Exception
///////////////////////////////////////////////////////////////////////////////

//-----------------------------------------------------------------------------
Exception::Exception() : mWhat(EMPTY) {
}

//-----------------------------------------------------------------------------
Exception::Exception(const char *what) : mWhat(what) {    
}

//-----------------------------------------------------------------------------
Exception::Exception(const std::string &what) : mWhat(what) {    
}

//-----------------------------------------------------------------------------
const char* Exception::what() const throw() {
   return mWhat.c_str(); 
}

///////////////////////////////////////////////////////////////////////////////
// Argument exception
///////////////////////////////////////////////////////////////////////////////

//-----------------------------------------------------------------------------
ArgumentException::ArgumentException() : mArgument(EMPTY) {
}

//-----------------------------------------------------------------------------
ArgumentException::ArgumentException(const char *what)
	: Exception(what), mArgument(EMPTY) {
}

//-----------------------------------------------------------------------------
ArgumentException::ArgumentException(const std::string &what)
	: Exception(what), mArgument(EMPTY) {
}

//-----------------------------------------------------------------------------
ArgumentException::ArgumentException(const char *argName, const char *what)
	: Exception((string(what) + " " + argName).c_str()), mArgument(argName) {
}

//-----------------------------------------------------------------------------
const char* ArgumentException::getArgumentName() const {
	return mArgument.c_str();
}

///////////////////////////////////////////////////////////////////////////////
// Argument null exception
///////////////////////////////////////////////////////////////////////////////

//-----------------------------------------------------------------------------
ArgumentNullException::ArgumentNullException()
	: ArgumentException("Argument should not be null") {
}

//-----------------------------------------------------------------------------
ArgumentNullException::ArgumentNullException(const char* argName)
	: ArgumentException(argName, "Argument should not be null") {
}

///////////////////////////////////////////////////////////////////////////////
// Argument out of range exception
///////////////////////////////////////////////////////////////////////////////

//-----------------------------------------------------------------------------
ArgumentOutOfRangeException::ArgumentOutOfRangeException()
	: ArgumentException("Argument does not falling within expected range") {
}

//-----------------------------------------------------------------------------
ArgumentOutOfRangeException::ArgumentOutOfRangeException(const char* argName)
	: ArgumentException(argName, "Argument does not falling within expected range") {
}

//-----------------------------------------------------------------------------
ArgumentOutOfRangeException::ArgumentOutOfRangeException(const char* argName, const char* what)
	: ArgumentException(argName, what) {
}

///////////////////////////////////////////////////////////////////////////////
// Invalid operation exception
///////////////////////////////////////////////////////////////////////////////

//-----------------------------------------------------------------------------
InvalidOperationException::InvalidOperationException(const char* what)
	: Exception(what) {
}

///////////////////////////////////////////////////////////////////////////////
// Not implemented exception
///////////////////////////////////////////////////////////////////////////////

//-----------------------------------------------------------------------------
NotImplementedException::NotImplementedException() 
	: Exception("Not implemented") {	
}

//-----------------------------------------------------------------------------
NotImplementedException::NotImplementedException(const char* what)
	: Exception(what) {
}

///////////////////////////////////////////////////////////////////////////////
// Not supported exception
///////////////////////////////////////////////////////////////////////////////

//-----------------------------------------------------------------------------
NotSupportedException::NotSupportedException(const char* what)
	: Exception(what) {
}
